home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d875.lha / Blanker / Source.lha / Source / winhand.c < prev   
C/C++ Source or Header  |  1993-05-24  |  9KB  |  321 lines
  1. /** DoRev Header ** Do not edit! **
  2. *
  3. * Name             :  winhand.c
  4. * Copyright        :  Free Software
  5. * Creation date    :  12-May-93
  6. * Translator       :  SAS/C 6.2
  7. * Compiler opts.   :  See Makefile
  8. *
  9. * Date       Rev  Author               Comment
  10. * ---------  ---  -------------------  ----------------------------------------
  11. * 22-May-93    1  Michael D. Bayne     Removed mouse blanker
  12. * 12-May-93    0  Michael D. Bayne     Gadget/window handling for Blanker
  13. *
  14. *** DoRev End **/
  15.  
  16. #include <exec/types.h>
  17. #include <exec/memory.h>
  18. #include <intuition/intuition.h>
  19. #include <libraries/gadtools.h>
  20. #include <libraries/commodities.h>
  21. #include <libraries/reqtools.h>
  22. #include <graphics/displayinfo.h>
  23.  
  24. #include <dos/dos.h>
  25. #include <dos/dostags.h>
  26.  
  27. #include <clib/exec_protos.h>
  28. #include <clib/intuition_protos.h>
  29. #include <clib/gadtools_protos.h>
  30. #include <clib/commodities_protos.h>
  31. #include <clib/graphics_protos.h>
  32. #include <clib/reqtools_protos.h>
  33. #include <clib/alib_protos.h>
  34. #include <clib/dos_protos.h>
  35.  
  36. #include "defs.h"
  37. #include "Blanker.h"
  38.  
  39. LONG UpdateCX( void );
  40. void getInfo( UBYTE * );
  41. LONG getBlanker( void );
  42.  
  43. extern    struct    Task *bTask, *Task;
  44. extern    struct    Window *BlankerWnd;
  45. extern    struct    MsgPort *blankerPort, *modulePort;
  46. extern    struct    bMessage bMsg;
  47. extern    struct    Gadget *BlankerGadgets[];
  48. extern    struct    bPrefObject bPrefs;
  49. extern    CxObj    *bBroker, *pHotKey, *bHotKey;
  50. extern    ULONG    validPrefs;
  51.     UBYTE    prefName[108] = "Blanker.prefs", prefDir[108] = "SYS:Prefs/Presets", modInfo[64];
  52.  
  53. void setPrefs( struct bPrefObject *cP, UBYTE gad )
  54. {
  55.     struct    NameInfo sInf;
  56.  
  57.     if(( gad == GD_TOUT )||( gad == Blanker_CNT ))
  58.         GT_SetGadgetAttrs( BlankerGadgets[GD_TOUT], BlankerWnd, 0L, GTIN_Number, (cP->bTimeout)/10, 0L );
  59.     if(( gad == GD_PKEY )||( gad == Blanker_CNT ))
  60.         GT_SetGadgetAttrs( BlankerGadgets[GD_PKEY], BlankerWnd, 0L, GTST_String, cP->pKey, 0L );
  61.     if(( gad == GD_BKEY )||( gad == Blanker_CNT ))
  62.         GT_SetGadgetAttrs( BlankerGadgets[GD_BKEY], BlankerWnd, 0L, GTST_String, cP->bKey, 0L );
  63.     if(( gad == GD_MDISPLAY )||( gad == Blanker_CNT )) {
  64.         if( GetDisplayInfoData( 0l, ( UBYTE * )&sInf, sizeof( struct NameInfo ), DTAG_NAME, cP->sMod ))
  65.             GT_SetGadgetAttrs( BlankerGadgets[GD_MDISPLAY], BlankerWnd, NULL, GTTX_Text, sInf.Name, NULL );
  66.         else GT_SetGadgetAttrs( BlankerGadgets[GD_MDISPLAY], BlankerWnd, NULL, GTTX_Text, "No Monitor Info", NULL );
  67.         GT_SetGadgetAttrs( BlankerGadgets[GD_SDEP], BlankerWnd, NULL, GTNM_Number, 1<<(cP->sDep), 0L );
  68.     }
  69.     if(( gad == GD_MODINFO )||( gad == Blanker_CNT ))
  70.         GT_SetGadgetAttrs( BlankerGadgets[GD_MODINFO], BlankerWnd, NULL, GTTX_Text, modInfo, NULL );
  71.     if( gad == Blanker_CNT )
  72.         GT_SetGadgetAttrs( BlankerGadgets[GD_MEMRES], BlankerWnd, 0L, GTCY_Active, bPrefs.resident, TAG_END );
  73. }
  74.  
  75. void loadPrefs( char *name, char *dir, struct bPrefObject *bPO )
  76. {
  77.     char path[256];
  78.     BPTR prefFile;
  79.  
  80.     CopyMem( dir, path, 108 );
  81.     if(( AddPart( path, name, 256 ))&&( prefFile = Open( path, MODE_OLDFILE ))) {
  82.         if( FRead( prefFile, bPO, 1, sizeof( struct bPrefObject )) == sizeof( struct bPrefObject ))
  83.             validPrefs = 1;
  84.         else {
  85.             rtEZRequest( "Error reading prefs file.", "OK", 0L, 0L, DEF_TAGS );
  86.             validPrefs = 0;
  87.         }
  88.         Close( prefFile );
  89.     } else rtEZRequest( "Could not open prefs file.", "OK", 0L, 0L, DEF_TAGS );
  90. }
  91.  
  92. void savePrefs( char *name, char *dir, struct bPrefObject *bPO )
  93. {
  94.     char path[256];
  95.     BPTR prefFile;
  96.  
  97.     CopyMem( dir, path, 108 );
  98.     if(( AddPart( path, name, 256 ))&&( prefFile = Open( path, MODE_NEWFILE ))) {
  99.         FWrite( prefFile, bPO, 1, sizeof( struct bPrefObject ));
  100.         Close( prefFile );
  101.     } else rtEZRequest( "Could not open prefs file.", "OK", 0L, 0L, DEF_TAGS );
  102. }
  103.  
  104. void defBlanker( void )
  105. {
  106.     struct    Screen    *Scr;
  107.     UWORD   CTable[] = { 0x0222, 0x0AAA, 0x0AAA };
  108.  
  109.     bTask = Task;
  110.  
  111.     Scr = OpenScreenTags( 0l, SA_DisplayID, bPrefs.sMod, SA_Depth, 1, SA_Quiet, TRUE, SA_Overscan,
  112.         OSCAN_STANDARD, TAG_DONE );
  113.     LoadRGB4( &(Scr->ViewPort), CTable, 2 );
  114.  
  115.     Wait( SIGBREAKF_CTRL_C );
  116.  
  117.     CloseScreen( Scr );
  118. }
  119.  
  120. int TOUTClicked( void )
  121. {
  122.     bPrefs.bTimeout = 10*(((struct StringInfo*)(BlankerGadgets[GD_TOUT])->SpecialInfo)->LongInt);
  123.     return( UpdateCX() );
  124. }
  125.  
  126. int BKEYClicked( void )
  127. {
  128.     CopyMem( ((struct StringInfo *)(BlankerGadgets[GD_BKEY])->SpecialInfo )->Buffer, bPrefs.bKey, 256 );
  129.     return( UpdateCX() );
  130. }
  131.  
  132. int PKEYClicked( void )
  133. {
  134.     CopyMem( ((struct StringInfo *)(BlankerGadgets[GD_PKEY])->SpecialInfo )->Buffer, bPrefs.pKey, 256 );
  135.     return( UpdateCX() );
  136. }
  137.  
  138. int HIDEClicked( void )
  139. {
  140.     return( CLOSEWIN );
  141. }
  142.  
  143. int SAVEClicked( void )
  144. {
  145.     savePrefs( "Blanker.prefs", "ENVARC:", &bPrefs );
  146.     savePrefs( "Blanker.prefs", "ENV:", &bPrefs );
  147.     return( OK );
  148. }
  149.  
  150. int QUITClicked( void )
  151. {
  152.     return( QUIT );
  153. }
  154.  
  155. int SMODEClicked( void )
  156. {
  157.     struct rtScreenModeRequester *smRequest;
  158.  
  159.     if( smRequest = rtAllocRequestA( RT_SCREENMODEREQ, 0l )) {
  160.         rtChangeReqAttr( smRequest, RTSC_DisplayID, bPrefs.sMod, RTSC_DisplayDepth, bPrefs.sDep, TAG_END );
  161.         if( rtScreenModeRequest( smRequest, "Screen Mode", RTSC_Flags, SCREQF_DEPTHGAD|SCREQF_NONSTDMODES,
  162.             DEF_TAGS )) {
  163.             bPrefs.sDep = smRequest->DisplayDepth;
  164.             bPrefs.sMod = smRequest->DisplayID;
  165.             setPrefs( &bPrefs, GD_MDISPLAY );
  166.         }
  167.         rtFreeRequest( smRequest );
  168.     } else
  169.         rtEZRequestTags( "Not enough memory to allocate\nscreen mode requester.", "OK", 0l, 0l, DEF_TAGS );
  170.     return( OK );
  171. }
  172.  
  173. int MEMRESClicked( void )
  174. {
  175.     if( modulePort ) {
  176.         bMsg.bm_Type = BM_UNLOAD;
  177.         PutMsg( modulePort, ( struct Message * )( &bMsg ));
  178.         WaitPort( blankerPort );
  179.         GetMsg( blankerPort );
  180.         modulePort = 0l;
  181.     }
  182.     bPrefs.resident = BlankerMsg.Code;
  183.     return( OK );
  184. }
  185.  
  186. int BMODClicked( void )
  187. {
  188.     APTR    lock = rtLockWindow( BlankerWnd );
  189.  
  190.     if( getBlanker()) {
  191.         if( bPrefs.resident ) bMsg.bm_Type = BM_PREFS;
  192.         else bMsg.bm_Type = BM_PREFS|BM_QUIT;
  193.         bMsg.bm_Valid = validPrefs;
  194.         bMsg.prefData = bPrefs.prefData;
  195.         PutMsg( modulePort, ( struct Message * )( &bMsg ));
  196.         WaitPort( blankerPort );
  197.         GetMsg( blankerPort );
  198.         if( !bPrefs.resident ) modulePort = 0l;
  199.         validPrefs = 1;
  200.     } else rtEZRequest( "No module loaded.", "Ok", 0L, 0L, DEF_TAGS );
  201.  
  202.     rtUnlockWindow( BlankerWnd, lock );
  203.     return( OK );
  204. }
  205.  
  206. int LMODClicked( void )
  207. {
  208.     return( BlankerLoadMod());
  209. }
  210.  
  211. int BlankerOpen( void )
  212. {
  213.     struct rtFileRequester *fRequest;
  214.  
  215.     if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
  216.         rtChangeReqAttr( fRequest, RTFI_Dir, prefDir, RTFI_MatchPat, "#?.prefs", TAG_END );
  217.         if( rtFileRequest( fRequest, prefName, "Please choose prefs file...", RTFI_Flags, FREQF_PATGAD,
  218.             DEF_TAGS )) {
  219.             loadPrefs( prefName, fRequest->Dir, &bPrefs );
  220.             setPrefs( &bPrefs, Blanker_CNT );
  221.             UpdateCX();
  222.         }
  223.     } else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
  224.     return( OK );
  225. }
  226.  
  227. int BlankerSaveAs( void )
  228. {
  229.     struct rtFileRequester *fRequest;
  230.  
  231.     if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
  232.         rtChangeReqAttr( fRequest, RTFI_Dir, prefDir, RTFI_MatchPat, "#?.prefs", TAG_END );
  233.         if( rtFileRequest( fRequest, prefName, "Please choose a save file...", RTFI_Flags,
  234.             FREQF_SAVE|FREQF_PATGAD, DEF_TAGS )) savePrefs( prefName, fRequest->Dir, &bPrefs );
  235.     } else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
  236.     return( OK );
  237. }
  238.  
  239. int BlankerAbout( void )
  240. {
  241.     rtEZRequestTags( BVERSION"\nby Michael D. Bayne", "Ok", 0L, 0L, DEF_TAGS );
  242.     return( OK );
  243. }
  244.  
  245. int BlankerLoadMod( void )
  246. {
  247.     struct rtFileRequester *fRequest;
  248.  
  249.     if( modulePort ) {
  250.         bMsg.bm_Type = BM_UNLOAD;
  251.         PutMsg( modulePort, ( struct Message * )( &bMsg ));
  252.         WaitPort( blankerPort );
  253.         GetMsg( blankerPort );
  254.         modulePort = 0l;
  255.     }
  256.  
  257.     if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
  258.         rtChangeReqAttr( fRequest, RTFI_Dir, bPrefs.modDir, TAG_END );
  259.         if( rtFileRequest( fRequest, bPrefs.modName, "Please choose blanker module...", RTFI_Flags,
  260.             FREQF_PATGAD, DEF_TAGS )) {
  261.             CopyMem( fRequest->Dir, bPrefs.modDir, 108 );
  262.             validPrefs = 0;
  263.             getInfo( modInfo );
  264.             setPrefs( &bPrefs, GD_MODINFO );
  265.         }
  266.     } else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
  267.     return( OK );
  268. }
  269.  
  270. int BlankerQuit( void )
  271. {
  272.     return( QUIT );
  273. }
  274.  
  275. int BlankerLSaved( void )
  276. {
  277.     loadPrefs( "Blanker.prefs", "ENVARC:", &bPrefs );
  278.     setPrefs( &bPrefs, Blanker_CNT );
  279.     UpdateCX();
  280.     return( OK );
  281. }
  282.  
  283. int BlankerCloseWindow( void )
  284. {
  285.     return( CLOSEWIN );
  286. }
  287.  
  288. int BlankerVanillaKey( void )
  289. {
  290.     switch( BlankerMsg.Code ) {
  291.     case 'c':
  292.         return( SMODEClicked() );
  293.     case 'r':
  294.         return( BMODClicked() );
  295.     case 'l':
  296.         return( BlankerLoadMod());
  297.     case 'm':
  298.         GT_SetGadgetAttrs( BlankerGadgets[GD_MEMRES], BlankerWnd, 0L, GTCB_Checked,
  299.         bPrefs.resident = !bPrefs.resident, TAG_END );
  300.         return( OK );
  301.     case 't':
  302.         ActivateGadget( BlankerGadgets[GD_TOUT], BlankerWnd, 0l );
  303.         return( OK );
  304.     case 'b':
  305.         ActivateGadget( BlankerGadgets[GD_BKEY], BlankerWnd, 0l );
  306.         return( OK );
  307.     case 'p':
  308.         ActivateGadget( BlankerGadgets[GD_PKEY], BlankerWnd, 0l );
  309.         return( OK );
  310.     case 'h':
  311.         return( HIDEClicked() );
  312.     case 's':
  313.         return( SAVEClicked() );
  314.     case 'q':
  315.         return( QUIT );
  316.     default:
  317.         return( OK );
  318.     }
  319. }
  320.  
  321.